package com.zx.cloud.service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.lianlianpay.security.utils.LianLianPaySecurity;
import com.lianpay.api.util.TraderRSAUtil;
import com.zx.cloud.ApiVersion;
import com.zx.cloud.domain.AuthorizationApplyForBean;
import com.zx.cloud.domain.ClientBankCard;
import com.zx.cloud.domain.ClientInfo;
import com.zx.cloud.domain.ConfirmPaymentRequestBean;
import com.zx.cloud.domain.DateAndAmountBean;
import com.zx.cloud.domain.LoanOrder;
import com.zx.cloud.domain.PaymentRequestBean;
import com.zx.cloud.domain.QueryPaymentRequestBean;
import com.zx.cloud.domain.RepayOrder;
import com.zx.cloud.domain.RepaymentPlanBean;
import com.zx.cloud.domain.RepaymentRequestBean;
import com.zx.cloud.domain.RiskManagement;
import com.zx.cloud.domain.SmsParamBean;
import com.zx.cloud.domain.enums.PaymentStatusEnum;
import com.zx.cloud.domain.enums.RetCodeEnum;
import com.zx.cloud.persistence.ClientBankCardMapper;
import com.zx.cloud.persistence.ClientInfoMapper;
import com.zx.cloud.util.HttpRequest;
import com.zx.cloud.util.PaymentConstant;
import com.zx.cloud.util.SignUtil;

/**
 * @Description:
 *
 * @author       Yan Weiwei
 * @Create Time: 2017年11月16日上午10:58:16
 */
@Service
@Transactional
public class PayForService {
	
	private static final Logger LOGGER = LoggerFactory.getLogger(PayForService.class);
	
	@Value("${pay.access.callback.url}")
	private String callbackUrl;
	
	@Autowired
	private ClientBankCardMapper clientBankCardMapper;
	
	@Autowired
    private ClientInfoMapper clientInfoMapper;

	/*
	 * 生成连连支付申请订单
	 */
	public Map<String, Object> handlePayment(LoanOrder loanOrder) throws Exception{
		
		Map<String, Object> resultMap = new HashMap<String, Object>();
		
		PaymentRequestBean paymentRequestBean = new PaymentRequestBean();
		
		paymentRequestBean.setNo_order(loanOrder.getOrderNo());
		paymentRequestBean.setDt_order(DateFormatUtils.format(new Date(), "yyyyMMddHHmmss"));
		paymentRequestBean.setMoney_order(loanOrder.getActualAmount().setScale(2, BigDecimal.ROUND_HALF_UP)+"");
		paymentRequestBean.setCard_no(loanOrder.getCardNo());
		paymentRequestBean.setAcct_name(loanOrder.getRealName());
		paymentRequestBean.setInfo_order("小额贷款");
		paymentRequestBean.setFlag_card("0");
		paymentRequestBean.setMemo("代付");
		paymentRequestBean.setNotify_url(callbackUrl+ApiVersion.API_V1_PREFIX+"/payfor/receiveNotify");
		paymentRequestBean.setOid_partner(PaymentConstant.OID_PARTNER);
		paymentRequestBean.setApi_version(PaymentConstant.API_VERSION);
		paymentRequestBean.setSign_type(PaymentConstant.SIGN_TYPE);
		LOGGER.info(SignUtil.genRSASign(new JSONObject(paymentRequestBean)));
		paymentRequestBean.setSign(SignUtil.genRSASign(new JSONObject(paymentRequestBean)));
		
		String jsonStr = new JSONObject(paymentRequestBean).toString();
		resultMap.put("request", jsonStr);
		LOGGER.info("********************************************付款接口原始请求报文：" + jsonStr+"********************************************");
		
		String encryptStr = LianLianPaySecurity.encrypt(jsonStr, PaymentConstant.PUBLIC_KEY_ONLINE);
		if (StringUtils.isEmpty(encryptStr)) {
			LOGGER.error("********************************************加密异常********************************************");
			resultMap.put("resultCode", "1000");
			resultMap.put("resultData", "加密异常");
			return resultMap;
		}
		
		JSONObject json = new JSONObject();
		json.put("oid_partner", PaymentConstant.OID_PARTNER);
		json.put("pay_load", encryptStr);
		LOGGER.info("**************************************************************");
		LOGGER.info("**************************************************************");
		LOGGER.info("***********************************付款接口请求报文：" + json.toString()+"***********************************");
		String response = HttpRequest.post("https://instantpay.lianlianpay.com/paymentapi/payment.htm").contentType("application/json","UTF-8").acceptJson().send(json.toString()).body();
		LOGGER.info("***********************************付款接口返回响应报文：" + response+"***********************************");
		LOGGER.info("***********************************");
		LOGGER.info("***********************************");
		if(StringUtils.isEmpty(response)){
			// 出现异常时调用订单查询，明确订单状态，不能私自设置订单为失败状态，以免造成这笔订单在连连付款成功了，而商户设置为失败
			queryPaymentAndDealBusiness(paymentRequestBean.getNo_order());
		}else{
			JSONObject jsonObject = new JSONObject(response);
			String retCode = jsonObject.getString("ret_code");
			
			resultMap.put("response", response);
			if(retCode.equals("0000")){
				boolean signCheck = TraderRSAUtil.checksign(PaymentConstant.PUBLIC_KEY_ONLINE,
						SignUtil.genSignData(new JSONObject(response)), jsonObject.getString("sign"));
				if(!signCheck){
					// 传送数据被篡改，可抛出异常，再人为介入检查原因
					LOGGER.error("***********************************返回结果验签异常,可能数据被篡改***********************************");
					resultMap.put("resultCode", "2000");
					resultMap.put("resultData", "验签异常");
					return resultMap;
				}
				LOGGER.info("**************************************************************");
				LOGGER.info("**************************************************************");
				LOGGER.info("***********************************"+paymentRequestBean.getNo_order() + "订单处于付款处理中***********************************");
				LOGGER.info("**************************************************************");
				LOGGER.info("**************************************************************");
				resultMap.put("resultCode", "3000");
				resultMap.put("serialNumber", jsonObject.getString("oid_paybill"));
				resultMap.put("resultData", "付款处理");
				
				// 已生成连连支付单，付款处理中（交易成功，不是指付款成功，是指跟连连流程正常），商户可以在这里处理自已的业务逻辑（或者不处理，在异步回调里处理逻辑）,最终的付款状态由异步通知回调告知
			}else if(retCode.equals("4002") || retCode.equals("4004")){
				LOGGER.error("***********************************确认付款接口**************************");
				// 当调用付款申请接口返回4002，4003，4004,会同时返回验证码，用于确认付款接口
				// 对于疑似重复订单，需先人工审核这笔订单是否正常的付款请求，而不是系统产生的重复订单，确认后再调用确认付款接口或者在连连商户站后台操作疑似订单，api不调用确认付款接口
				// 对于疑似重复订单，也可不做处理，
				// TODO
				String confirmCode = jsonObject.getString("confirm_code"); //人工处理
				resultMap.put("resultCode", "4000");
				resultMap.put("resultData", confirmCode);
			}else if (RetCodeEnum.isNeedQuery(retCode)) {
				LOGGER.error("***********************************f调用付款结果查询***********************************");
				// 出现1002，2005，4006，4007，4009，9999这6个返回码时（或者对除了0000之后的code都查询一遍查询接口）调用付款结果查询接口，明确订单状态，不能私自设置订单为失败状态，以免造成这笔订单在连连付款成功了，而商户设置为失败
				// 第一次测试对接时，返回{"ret_code":"4007","ret_msg":"敏感信息解密异常"},可能原因报文加密用的公钥改动了,demo中的公钥是连连公钥，商户生成的公钥用于上传连连商户站用于连连验签，生成的私钥用于加签
				queryPaymentAndDealBusiness(paymentRequestBean.getNo_order());
				resultMap.put("resultCode", "5000");
				resultMap.put("resultData", "处理异常");
			} else {
				// 返回其他code时，可将订单置为失败
				// TODO
				LOGGER.error("***********************************failure***********************************");
				resultMap.put("resultCode", "6000");
				resultMap.put("resultData", "请求失败");
			}
		}
		
		return resultMap;
	}
	
	/*
	 * 生成连连支付支付订单
	 */
	public void handleConfirmPayment(LoanOrder loanOrder, String confirmCode) throws Exception {
		ConfirmPaymentRequestBean paymentRequestBean = new ConfirmPaymentRequestBean();
		paymentRequestBean.setNo_order(loanOrder.getOrderNo());
		if(StringUtils.isNotEmpty(confirmCode)){
			paymentRequestBean.setConfirm_code(confirmCode);
		}
		paymentRequestBean.setNotify_url(callbackUrl+ApiVersion.API_V1_PREFIX+"/payfor/receiveConfirmNotify");
		paymentRequestBean.setOid_partner(PaymentConstant.OID_PARTNER);
		paymentRequestBean.setApi_version(PaymentConstant.API_VERSION);
		paymentRequestBean.setSign_type(PaymentConstant.SIGN_TYPE);
		paymentRequestBean.setSign(SignUtil.genRSASign(new JSONObject(paymentRequestBean)));
		String jsonStr = new JSONObject(paymentRequestBean).toString();
		LOGGER.info("付款接口原始请求报文：" + jsonStr);
		String encryptStr = LianLianPaySecurity.encrypt(jsonStr, PaymentConstant.PUBLIC_KEY_ONLINE);

		if (StringUtils.isEmpty(encryptStr)) {
			LOGGER.error("***********************************加密异常***********************************");
			return;
		}

		JSONObject json = new JSONObject();
		json.put("oid_partner", PaymentConstant.OID_PARTNER);
		json.put("pay_load", encryptStr);
		
		LOGGER.info("***********************************付款接口请求报文：" + json.toString()+"***********************************");

		String response = HttpRequest.post("https://instantpay.lianlianpay.com/paymentapi/confirmPayment.htm").contentType("application/json","UTF-8").acceptJson().send(json.toString()).body();
		LOGGER.info("***********************************确认付款接口返回响应报文：" + response+"**************************************");
		if (StringUtils.isEmpty(response)) {
			// 出现异常时调用订单查询，明确订单状态，不能私自设置订单为失败状态，以免造成这笔订单在连连付款成功了，而商户设置为失败
			queryPaymentAndDealBusiness(paymentRequestBean.getNo_order());
		} else {
			JSONObject jsonObject = new JSONObject(response);
			String retCode = (String)jsonObject.get("ret_code");
			// 对返回0000时验证签名
			if (retCode.equals("0000")) {
				// 先对结果验签
				boolean signCheck = TraderRSAUtil.checksign(PaymentConstant.PUBLIC_KEY_ONLINE,
						SignUtil.genSignData(new JSONObject(response)), (String)jsonObject.get("sign"));
				if (!signCheck) {
					// 传送数据被篡改，可抛出异常，再人为介入检查原因
					LOGGER.error("***********************************返回结果验签异常,可能数据被篡改***********************************");
					return;
				}
				LOGGER.info("***********************************"+paymentRequestBean.getNo_order() + "订单处于付款处理中***********************************");
				// 已生成连连支付单，付款处理中（交易成功，不是指付款成功，是指跟连连流程正常），商户可以在这里处理自已的业务逻辑（或者不处理，在异步回调里处理逻辑）,最终的付款状态由异步通知回调告知
			} else if (RetCodeEnum.isNeedQuery(retCode)) {
				// 出现1002，2005，4006，4007，4009，9999这6个返回码时（或者对除了0000之后的code都查询一遍查询接口）调用订单查询，明确订单状态，不能私自设置订单为失败状态，以免造成这笔订单在连连付款成功了，而商户设置为失败
				// 第一次测试对接时，返回{"ret_code":"4007","ret_msg":"敏感信息解密异常"},可能原因报文加密用的公钥改动了,demo中的公钥是连连公钥，商户生成的公钥用于上传连连商户站用于连连验签，生成的私钥用于加签
				queryPaymentAndDealBusiness(paymentRequestBean.getNo_order());
			} else {
				// 返回其他code时，可将订单置为失败
				// TODO
				LOGGER.error("***********************************failure***********************************");
			}
		}
	}
	/*
	 * 自动还款扣款授权申请接口
	 */
	public Map<String, Object> handleAuthorizationApplyFor(RepayOrder repayOrder) throws Exception{
		Map<String, Object> resultMap = new HashMap<String, Object>();
		LOGGER.info("***************自动还款扣款授权申请接口***********订单细信息：*********"+repayOrder+"***********************************");
		
		AuthorizationApplyForBean authorizationApplyForBean = new AuthorizationApplyForBean();
		authorizationApplyForBean.setUser_id(repayOrder.getClientId().toString());
		authorizationApplyForBean.setOid_partner(PaymentConstant.OID_PARTNER);
		authorizationApplyForBean.setApi_version(PaymentConstant.API_VERSION);
		
		RepaymentPlanBean repaymentPlanBean = new RepaymentPlanBean();
		List<DateAndAmountBean> daList = new ArrayList<DateAndAmountBean>();
		DateAndAmountBean dateAndAmountBean = new DateAndAmountBean();
		dateAndAmountBean.setDate(DateFormatUtils.format(new Date(), "yyyy-MM-dd"));
		dateAndAmountBean.setAmount(repayOrder.getActualRepayment().setScale(2, BigDecimal.ROUND_HALF_UP).toString());
		daList.add(dateAndAmountBean);
		repaymentPlanBean.setRepaymentPlan(daList);
		authorizationApplyForBean.setRepayment_plan(new JSONObject(repaymentPlanBean).toString());
		authorizationApplyForBean.setRepayment_no(DateFormatUtils.format(new Date(), "yyyyMMdd"));
		SmsParamBean smsParamBean = new SmsParamBean();
		smsParamBean.setContact_way("123456789");
		smsParamBean.setContract_type("随意钱包");
		authorizationApplyForBean.setSms_param(new JSONObject(smsParamBean).toString());
		authorizationApplyForBean.setPay_type("D");
		ClientBankCard clientBankCard = clientBankCardMapper.findByClientID(repayOrder.getClientId());
		if(null != clientBankCard){
			authorizationApplyForBean.setNo_agree(clientBankCard.getAgreeNo());
		}
		authorizationApplyForBean.setSign_type(PaymentConstant.SIGN_TYPE);
		authorizationApplyForBean.setSign(SignUtil.genRSASign(new JSONObject(authorizationApplyForBean)));
		
		String jsonStr = new JSONObject(authorizationApplyForBean).toString();
		resultMap.put("request", jsonStr);
		LOGGER.info("***********************************授权申请接口原始请求报文：" + jsonStr);
		
		String response = HttpRequest.post("https://repaymentapi.lianlianpay.com/agreenoauthapply.htm").contentType("application/json","UTF-8").acceptJson().send(jsonStr).body();
		LOGGER.info("***********************************授权申请接口返回响应报文：" + response+"***********************************");
		if (StringUtils.isEmpty(response)) {
			// 出现异常时调用订单查询，明确订单状态，不能私自设置订单为失败状态，以免造成这笔订单在连连付款成功了，而商户设置为失败
		} else {
			JSONObject jsonObject = new JSONObject(response);
			String retCode = jsonObject.getString("ret_code");
			resultMap.put("response", response);
			// 对返回0000时验证签名
			if (retCode.equals("0000")) {
				// 先对结果验签
				boolean signCheck = TraderRSAUtil.checksign(PaymentConstant.PUBLIC_KEY_ONLINE,
						SignUtil.genSignData(new JSONObject(response)), jsonObject.getString("sign"));
				if (!signCheck) {
					// 传送数据被篡改，可抛出异常，再人为介入检查原因
					LOGGER.error("***********************************返回结果验签异常,可能数据被篡改***********************************");
					resultMap.put("resultCode", "2000");
					resultMap.put("resultData", "验签异常");
					return resultMap;
				}
				// 已生成连连支付单，付款处理中（交易成功，不是指付款成功，是指跟连连流程正常），商户可以在这里处理自已的业务逻辑（或者不处理，在异步回调里处理逻辑）,最终的付款状态由异步通知回调告知
				resultMap.put("resultCode", "3000");
				String repaymentNo = jsonObject.getString("repayment_no");
				resultMap.put("repaymentNo", repaymentNo);
				resultMap.put("resultData", "付款处理");
			} else if (RetCodeEnum.isNeedQuery(retCode)) {
				// 出现1002，2005，4006，4007，4009，9999这6个返回码时（或者对除了0000之后的code都查询一遍查询接口）调用订单查询，明确订单状态，不能私自设置订单为失败状态，以免造成这笔订单在连连付款成功了，而商户设置为失败
				// 第一次测试对接时，返回{"ret_code":"4007","ret_msg":"敏感信息解密异常"},可能原因报文加密用的公钥改动了,demo中的公钥是连连公钥，商户生成的公钥用于上传连连商户站用于连连验签，生成的私钥用于加签
				resultMap.put("resultCode", "5000");
				resultMap.put("resultData", "处理异常");
			} else {
				// 返回其他code时，可将订单置为失败
				// TODO
				LOGGER.error("***********************************failure***********************************");
				resultMap.put("resultCode", "6000");
				resultMap.put("resultData", "请求失败");
			}
		}
		return resultMap;
		
	}
	
	/*
	 * 银行卡还款扣款接口
	 */
	public Map<String, Object> handleRepayment(RepayOrder repayOrder, String repaymentNo) throws Exception{
		Map<String, Object> resultMap = new HashMap<String, Object>();
		
		RepaymentRequestBean repaymentRequestBean = new RepaymentRequestBean();
		repaymentRequestBean.setUser_id(repayOrder.getClientId().toString());
		repaymentRequestBean.setOid_partner(PaymentConstant.OID_PARTNER);
		repaymentRequestBean.setBusi_partner("101001");
		repaymentRequestBean.setApi_version(PaymentConstant.API_VERSION);
		repaymentRequestBean.setNo_order(repayOrder.getTradeNumber());//申请交易流水号
		repaymentRequestBean.setDt_order(DateFormatUtils.format(new Date(), "yyyyMMddHHmmss"));
		repaymentRequestBean.setName_goods("自动还款");
		repaymentRequestBean.setMoney_order(repayOrder.getActualRepayment().setScale(2, BigDecimal.ROUND_HALF_UP).toString());
		repaymentRequestBean.setNotify_url(callbackUrl+ApiVersion.API_V1_PREFIX+"/payfor/receiveRepaymentNotify");
		RiskManagement risk = new RiskManagement(); //风控参数
		ClientInfo insEntity = clientInfoMapper.findClientById(repayOrder.getClientId());
		if(null != insEntity){
			risk.setUser_info_full_name(insEntity.getRealName());
			risk.setUser_info_id_no(insEntity.getIdNo());
		}
		repaymentRequestBean.setRisk_item(new JSONObject(risk).toString());
		repaymentRequestBean.setSchedule_repayment_date(DateFormatUtils.format(new Date(), "yyyy-MM-dd"));
		repaymentRequestBean.setRepayment_no(repaymentNo);
		repaymentRequestBean.setPay_type("D");
		ClientBankCard clientBankCard = clientBankCardMapper.findByClientID(repayOrder.getClientId());
		if(null != clientBankCard){
			repaymentRequestBean.setNo_agree(clientBankCard.getAgreeNo());
		}
		repaymentRequestBean.setSign_type(PaymentConstant.SIGN_TYPE);
		repaymentRequestBean.setSign(SignUtil.genRSASign(new JSONObject(repaymentRequestBean)));
		
		String jsonStr = new JSONObject(repaymentRequestBean).toString();
		resultMap.put("request", jsonStr);
		LOGGER.info("***********************************扣款接口原始请求报文：" + jsonStr);
		
		String response = HttpRequest.post("https://repaymentapi.lianlianpay.com/bankcardrepayment.htm").contentType("application/json","UTF-8").acceptJson().send(jsonStr).body();
		LOGGER.info("***********************************扣款接口返回响应报文：" + response+"***********************************");
		if (StringUtils.isEmpty(response)) {
			// 出现异常时调用订单查询，明确订单状态，不能私自设置订单为失败状态，以免造成这笔订单在连连付款成功了，而商户设置为失败
		} else {
			JSONObject jsonObject = new JSONObject(response);
			String retCode = jsonObject.getString("ret_code");
			
			resultMap.put("response", response);
			// 对返回0000时验证签名
			if (retCode.equals("0000")) {
				// 先对结果验签
				boolean signCheck = TraderRSAUtil.checksign(PaymentConstant.PUBLIC_KEY_ONLINE,
						SignUtil.genSignData(new JSONObject(response)), jsonObject.getString("sign"));
				if (!signCheck) {
					// 传送数据被篡改，可抛出异常，再人为介入检查原因
					LOGGER.error("***********************************返回结果验签异常,可能数据被篡改***********************************");
					resultMap.put("resultCode", "2000");
					resultMap.put("resultData", "验签异常");
					return resultMap;
				}
				LOGGER.info("***********************************"+repaymentRequestBean.getNo_order() + "订单处于付款处理中***********************************");
				// 已生成连连支付单，付款处理中（交易成功，不是指付款成功，是指跟连连流程正常），商户可以在这里处理自已的业务逻辑（或者不处理，在异步回调里处理逻辑）,最终的付款状态由异步通知回调告知
				resultMap.put("serialNumber", jsonObject.getString("oid_paybill"));
				resultMap.put("resultCode", "3000");
				resultMap.put("resultData", "付款处理");
			} else if (RetCodeEnum.isNeedQuery(retCode)) {
				// 出现1002，2005，4006，4007，4009，9999这6个返回码时（或者对除了0000之后的code都查询一遍查询接口）调用订单查询，明确订单状态，不能私自设置订单为失败状态，以免造成这笔订单在连连付款成功了，而商户设置为失败
				// 第一次测试对接时，返回{"ret_code":"4007","ret_msg":"敏感信息解密异常"},可能原因报文加密用的公钥改动了,demo中的公钥是连连公钥，商户生成的公钥用于上传连连商户站用于连连验签，生成的私钥用于加签
				resultMap.put("resultCode", "5000");
				resultMap.put("resultData", "处理异常");
			} else {
				// 返回其他code时，可将订单置为失败
				// TODO
				LOGGER.error("***********************************failure***********************************");
				resultMap.put("resultCode", "6000");
				resultMap.put("resultData", "请求失败");
			}
		}
		return resultMap;
	}
	
	/*
	 * 查询连连支付订单处理信息
	 */
	public static void queryPaymentAndDealBusiness(String orderNo) {
		// 连连内部测试环境数据
		QueryPaymentRequestBean queryRequestBean = new QueryPaymentRequestBean();
		queryRequestBean.setNo_order(orderNo);
		queryRequestBean.setOid_partner(PaymentConstant.OID_PARTNER);
		queryRequestBean.setApi_version(PaymentConstant.API_VERSION);
		queryRequestBean.setSign_type(PaymentConstant.SIGN_TYPE);
		queryRequestBean.setSign(SignUtil.genRSASign(new JSONObject(queryRequestBean)));
		String queryResult = HttpRequest.post("https://instantpay.lianlianpay.com/paymentapi/queryPayment.htm").contentType("application/json","UTF-8").acceptJson().send(queryRequestBean.toString()).body();
		LOGGER.info("***********************************实时付款查询接口响应报文：" + queryResult+"***********************************");
		if (StringUtils.isEmpty(queryResult)) {
			// 可抛异常，查看原因
			LOGGER.error("***********************************实时付款查询接口响应异常***********************************");
			return;
		}
		JSONObject json = new JSONObject(queryResult);

		// 先对结果验签
		boolean signCheck = TraderRSAUtil.checksign(PaymentConstant.PUBLIC_KEY_ONLINE,
				SignUtil.genSignData(json), json.getString("sign"));
		if (!signCheck) {
			// 传送数据被篡改，可抛出异常，再人为介入检查原因
			LOGGER.error("***********************************返回结果验签异常,可能数据被篡改***********************************");
			return;
		}
		String retCode = json.getString("ret_code");
		String resultPay = json.getString("result_pay");
		if (retCode.equals("0000")) {
			PaymentStatusEnum paymentStatusEnum = PaymentStatusEnum.getPaymentStatusEnumByValue(resultPay);
			// TODO商户根据订单状态处理自已的业务逻辑
			switch (paymentStatusEnum) {
			case PAYMENT_APPLY:
				// 付款申请，这种情况一般不会发生，如出现，请直接找连连技术处理
				break;
			case PAYMENT_CHECK:
				// 复核状态 TODO
				// 返回4002，4003，4004时，订单会处于复核状态，这时还未创建连连支付单，没提交到银行处理，如需对该订单继续处理，需商户先人工审核这笔订单是否是正常的付款请求，没问题后再调用确认付款接口
				// 如果对于复核状态的订单不做处理，可当做失败订单
				break;
			case PAYMENT_SUCCESS:
				// 成功 TODO
				break;
			case PAYMENT_FAILURE:
				// 失败 TODO
				break;
			case PAYMENT_DEALING:
				// 处理中 TODO
				break;
			case PAYMENT_RETURN:
				// 退款 TODO
				// 可当做失败（退款情况
				// 极小概率下会发生，个别银行处理机制是先扣款后打款给用户时再检验卡号信息是否正常，异常时会退款到连连商户账上）
				break;
			case PAYMENT_CLOSED:
				// 关闭 TODO 可当做失败 ，对于复核状态的订单不做处理会将订单关闭
				break;
			default:
				break;
			}
		} else if (retCode.equals("8901")) {
			// 订单不存在，这种情况可以用原单号付款，最好不要换单号，如换单号，在连连商户站确认下改订单是否存在，避免系统并发时返回8901，实际有一笔订单
		} else {
			// 查询异常（极端情况下才发生,对于这种情况，可人工介入查询，在连连商户站查询或者联系连连客服，查询订单状态）
			LOGGER.error("***********************************查询异常***********************************");
		}

	}
	
}
